/* -*- C++ -*-
 * File: mem_image.cpp
 * Copyright 2008-2021 LibRaw LLC (info@libraw.org)
 *
 * LibRaw mem_image/mem_thumb API test. Results should be same (bitwise) to
dcraw [-4] [-6] [-e]
 * Testing note: for ppm-thumbnails you should use dcraw -w -e for thumbnail
extraction

LibRaw is free software; you can redistribute it and/or modify
it under the terms of the one of two licenses as you choose:

1. GNU LESSER GENERAL PUBLIC LICENSE version 2.1
   (See file LICENSE.LGPL provided in LibRaw distribution archive for details).

2. COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0
   (See file LICENSE.CDDL provided in LibRaw distribution archive for details).


 */
#include <stdio.h>
#include <string.h>
#include <math.h>

#include "libraw/libraw.h"
#include <chrono>
#include <iostream>

#include <jpeglib.h>

#ifdef LIBRAW_WIN32_CALLS
#define snprintf _snprintf
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")
#else
#include <netinet/in.h>
#endif


void write_jpeg(libraw_processed_image_t *img, const char *basename, int quality)
{
  char fn[1024];
  if(img->colors != 1 && img->colors != 3)
  {
	printf("Only BW and 3-color images supported for JPEG output\n");
	return;
  }
  snprintf(fn, 1024, "%s.jpg", basename);
  FILE *f = fopen(fn, "wb");
  if (!f)
    return;
  struct jpeg_compress_struct cinfo;
  struct jpeg_error_mgr jerr;
  JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */
  int row_stride;          /* physical row width in image buffer */

  printf("the quality: %d \n", quality);
  cinfo.err = jpeg_std_error(&jerr);
  jpeg_create_compress(&cinfo);
  jpeg_stdio_dest(&cinfo, f);
  cinfo.image_width = img->width;      /* image width and height, in pixels */
  cinfo.image_height = img->height;
  cinfo.input_components = 3;  
  cinfo.optimize_coding = TRUE;

    // Since math coprocessors are common these days, FLOAT should be a bit more accurate AND fast (default is ISLOW)
    // (machine dependency is not really an issue, since we all run on x86 and having exactly the same file is not a requirement)
  cinfo.dct_method = JDCT_FLOAT; 
  cinfo.write_JFIF_header = FALSE;

  /* # of color components per pixel */
  cinfo.in_color_space = JCS_RGB;       /* colorspace of input image */
  jpeg_set_defaults(&cinfo);
  jpeg_set_quality(&cinfo, quality, TRUE);

    // Since math coprocessors are common these days, FLOAT should be a bit more accurate AND fast (default is ISLOW)
    // (machine dependency is not really an issue, since we all run on x86 and having exactly the same file is not a requirement)

    cinfo.comp_info[1].h_samp_factor = cinfo.comp_info[1].v_samp_factor = 1;
    cinfo.comp_info[2].h_samp_factor = cinfo.comp_info[2].v_samp_factor = 1;
    
    int subSamp = 1;
    if (subSamp == 1) {
        // Best compression, default of the JPEG library:  2x2, 1x1, 1x1 (4:2:0)
        cinfo.comp_info[0].h_samp_factor = cinfo.comp_info[0].v_samp_factor = 2;
    } else if (subSamp == 2) {
        // Widely used normal ratio 2x1, 1x1, 1x1 (4:2:2)
        cinfo.comp_info[0].h_samp_factor = 2;
        cinfo.comp_info[0].v_samp_factor = 1;
    } else if (subSamp == 3) {
        // Best quality 1x1 1x1 1x1 (4:4:4)
        cinfo.comp_info[0].h_samp_factor = cinfo.comp_info[0].v_samp_factor = 1;
    }


  jpeg_start_compress(&cinfo, TRUE);
  row_stride = img->width * img->colors; /* JSAMPLEs per row in image_buffer */
  while (cinfo.next_scanline < cinfo.image_height) {
    row_pointer[0] = &img->data[cinfo.next_scanline * row_stride];
    (void)jpeg_write_scanlines(&cinfo, row_pointer, 1);
  }
  jpeg_finish_compress(&cinfo);
  fclose(f);
  jpeg_destroy_compress(&cinfo);

  printf("finish write jpeg \n");
}


// no error reporting, only params check
void write_ppm(libraw_processed_image_t *img, const char *basename)
{
  if (!img)
    return;
  // type SHOULD be LIBRAW_IMAGE_BITMAP, but we'll check
  if (img->type != LIBRAW_IMAGE_BITMAP)
    return;
  if (img->colors != 3 && img->colors != 1)
  {
    printf("Only monochrome and 3-color images supported for PPM output\n");
    return;
   }

  char fn[1024];
  snprintf(fn, 1024, "%s.p%cm", basename, img->colors==1?'g':'p');
  FILE *f = fopen(fn, "wb");
  if (!f)
    return;
  fprintf(f, "P%d\n%d %d\n%d\n", img->colors/2 + 5, img->width, img->height, (1 << img->bits) - 1);
/*
  NOTE:
  data in img->data is not converted to network byte order.
  So, we should swap values on some architectures for dcraw compatibility
  (unfortunately, xv cannot display 16-bit PPMs with network byte order data
*/
#define SWAP(a, b)                                                             \
  {                                                                            \
    a ^= b;                                                                    \
    a ^= (b ^= a);                                                             \
  }
  if (img->bits == 16 && htons(0x55aa) != 0x55aa)
    for (unsigned i = 0; i < img->data_size-1; i += 2)
      SWAP(img->data[i], img->data[i + 1]);
#undef SWAP

  fwrite(img->data, img->data_size, 1, f);
  fclose(f);
}

void write_thumb(libraw_processed_image_t *img, const char *basename)
{
  if (!img)
    return;

  if (img->type == LIBRAW_IMAGE_BITMAP)
  {
    char fnt[1024];
    snprintf(fnt, 1024, "%s.thumb", basename);
    write_ppm(img, fnt);
  }
  else if (img->type == LIBRAW_IMAGE_JPEG)
  {
    char fn[1024];
    snprintf(fn, 1024, "%s.thumb.jpg", basename);
    FILE *f = fopen(fn, "wb");
    if (!f)
      return;
    fwrite(img->data, img->data_size, 1, f);
    fclose(f);
  }
}

int main(int ac, char *av[])
{
  int i, ret, output_thumbs = 0;
  int output_jpeg = 0, jpgqual = 90;
  // don't use fixed size buffers in real apps!

  std::chrono::high_resolution_clock::time_point total_start;
  std::chrono::high_resolution_clock::time_point total_finish;

  total_start = std::chrono::high_resolution_clock::now(); // 开始计时

  LibRaw RawProcessor;

  if (ac < 2)
  {
    printf("mem_image - LibRaw sample, to illustrate work for memory buffers.\n"
           "Emulates dcraw [-4] [-1] [-e] [-h]\n"
           "Usage: %s [-D] [-j[nn]] [-T] [-v] [-e] raw-files....\n"
           "\t-6 - output 16-bit PPM\n"
           "\t-4 - linear 16-bit data\n"
           "\t-e - extract thumbnails (same as dcraw -e in separate run)\n"
           "\t-j[qual] - output JPEG with qual quality (e.g. -j90)\n"
           "\t-h - use half_size\n", av[0]);
    return 0;
  }

  putenv((char *)"TZ=UTC"); // dcraw compatibility, affects TIFF datestamp field

#define P1 RawProcessor.imgdata.idata
#define S RawProcessor.imgdata.sizes
#define C RawProcessor.imgdata.color
#define T RawProcessor.imgdata.thumbnail
#define P2 RawProcessor.imgdata.other
#define OUT RawProcessor.imgdata.params

  for (i = 1; i < ac; i++)
  {
    if (av[i][0] == '-')
    {
      if (av[i][1] == '6' && av[i][2] == 0)
        OUT.output_bps = 16;
      if (av[i][1] == '4' && av[i][2] == 0)
      {
        OUT.output_bps = 16;
        OUT.gamm[0] = OUT.gamm[1] = OUT.no_auto_bright = 1;
      }
      if (av[i][1] == 'e' && av[i][2] == 0)
        output_thumbs++;
      if (av[i][1] == 'h' && av[i][2] == 0)
        OUT.half_size = 1;


      if (av[i][1] == 'j')
      {
        output_jpeg = 1;
        if(av[i][2] != 0)
        jpgqual = atoi(av[i]+2);
      } 
      continue;
    }

    if(output_jpeg && OUT.output_bps>8)
    {
      printf("JPEG is limited to 8 bit\n");
      OUT.output_bps = 8;
    }


     // 自动白平衡
    // OUT.auto_bright_thr=0;

    OUT.exp_correc=1; 
    OUT.exp_shift=4.0; 
    OUT.exp_preser=1.0;


    printf("Processing %s\n", av[i]);
    if ((ret = RawProcessor.open_file(av[i])) != LIBRAW_SUCCESS)
    {
      fprintf(stderr, "Cannot open %s: %s\n", av[i], libraw_strerror(ret));
      continue; // no recycle b/c open file will recycle itself
    }

    if ((ret = RawProcessor.unpack()) != LIBRAW_SUCCESS)
    {
      fprintf(stderr, "Cannot unpack %s: %s\n", av[i], libraw_strerror(ret));
      continue;
    }

    // we should call dcraw_process before thumbnail extraction because for
    // some cameras (i.e. Kodak ones) white balance for thumbnail should be set
    // from main image settings

    printf("start to dcraw_process\n");

    std::chrono::high_resolution_clock::time_point start;
    std::chrono::high_resolution_clock::time_point finish;

    start = std::chrono::high_resolution_clock::now(); // 开始计时

    ret = RawProcessor.dcraw_process();

    finish = std::chrono::high_resolution_clock::now(); // 结束计时

    std::cout << "0.dcraw_process time:" << std::chrono::duration_cast<std::chrono::milliseconds>(finish - start).count() << "ms.\n";

    if (LIBRAW_SUCCESS != ret)
    {
      fprintf(stderr, "Cannot do postprocessing on %s: %s\n", av[i],
              libraw_strerror(ret));
      if (LIBRAW_FATAL_ERROR(ret))
        continue;
    }


    start = std::chrono::high_resolution_clock::now(); // 结束计时
    libraw_processed_image_t *image = RawProcessor.dcraw_make_mem_image(&ret);
    finish = std::chrono::high_resolution_clock::now(); // 结束计时

    std::cout << "1.dcraw_make_mem_image time:" << std::chrono::duration_cast<std::chrono::milliseconds>(finish - start).count() << "ms.\n";
    if (image)
    {
      printf("start to write jpeg\n");
      start = std::chrono::high_resolution_clock::now(); // 

      if(output_jpeg){
        write_jpeg(image, av[i], jpgqual);
      }
      else{
        write_ppm(image, av[i]);
      }

      finish = std::chrono::high_resolution_clock::now(); // 结束计时
      std::cout << "2.is jpeg image:" << output_jpeg <<"  write image time:" << std::chrono::duration_cast<std::chrono::milliseconds>(finish - start).count() << "ms.\n";
    
      LibRaw::dcraw_clear_mem(image);
    }
    else
      fprintf(stderr, "Cannot unpack %s to memory buffer: %s\n", av[i],
              libraw_strerror(ret));

    if (output_thumbs)
    {
      printf("start to write thumbs jpeg \n");
      start = std::chrono::high_resolution_clock::now(); 

      if ((ret = RawProcessor.unpack_thumb()) != LIBRAW_SUCCESS)
      {
        fprintf(stderr, "Cannot unpack_thumb %s: %s\n", av[i],
                libraw_strerror(ret));
        if (LIBRAW_FATAL_ERROR(ret))
          continue; // skip to next file
      }
      else
      {
        libraw_processed_image_t *thumb =
            RawProcessor.dcraw_make_mem_thumb(&ret);
        if (thumb)
        {
          write_thumb(thumb, av[i]);
          LibRaw::dcraw_clear_mem(thumb);
        }
        else
          fprintf(stderr,
                  "Cannot unpack thumbnail of %s to memory buffer: %s\n", av[i],
                  libraw_strerror(ret));
      }

      finish = std::chrono::high_resolution_clock::now(); // 结束计时
      std::cout << "3.write thumb image time:" << std::chrono::duration_cast<std::chrono::milliseconds>(finish - start).count() << "ms.\n";
    
    }

    RawProcessor.recycle(); // just for show this call
  }

  total_finish = std::chrono::high_resolution_clock::now(); // 结束计时

  std::cout << "process end total time:" << std::chrono::duration_cast<std::chrono::milliseconds>(total_finish - total_start).count() << "ms.\n";

  return 0;
}